function calls

Basic Function Calls

• Overview: Calling a function in Scala involves specifying the function name followed by its arguments in parentheses, if any are required.
• Syntax:

  functionName(arg1, arg2, ..., argN)
  

• Example:

  def add(x: Int, y: Int): Int = x + y
  val result = add(5, 3)  // Calls the add function with 5 and 3 as arguments
  

Higher-Order Function Calls

• Overview: Higher-order functions are functions that take other functions as parameters or return them as results. Calling them involves passing functions as arguments.
• Example of Passing Functions as Arguments:

  def applyOperation(a: Int, b: Int, operation: (Int, Int) => Int): Int = operation(a, b)
  val sum = applyOperation(5, 3, (x, y) => x + y)  // Using a lambda expression as an argument
  

• Example of Using Functions Returned by Other Functions:

  def greeting(language: String): String => String = {
    language match {
      case "English" => (name: String) => s"Hello, $name!"
      case "Spanish" => (name: String) => s"Hola, $name!"
    }
  }
  val englishGreeting = greeting("English")
  println(englishGreeting("Alice"))  // Outputs: Hello, Alice!
  

Calling Functions with Named Arguments

• Overview: Scala allows calling functions with named arguments, letting you specify the name of the parameters explicitly, which can enhance readability and allow for arguments to be passed in any order.
• Syntax:

  functionName(paramName1 = value1, paramName2 = value2)
  

• Example:

  def printDetails(name: String, age: Int, country: String): Unit = {
    println(s"Name: $name, Age: $age, Country: $country")
  }
  printDetails(age = 30, name = "Alice", country = "Canada")  // Arguments are out of order but correctly named
  

Using Default and Optional Parameters

• Overview: Functions in Scala can define default values for parameters, allowing those parameters to be omitted when the function is called.
• Syntax:

  def functionName(param1: Type = defaultValue1, param2: Type = defaultValue2): ReturnType = { ... }
  

• Example:

  def log(message: String, level: String = "INFO"): Unit = println(s"[$level] $message")
  log("System startup")  // Level parameter is optional due to a default value
  

Best Practices in Function Calls

• Clarity and Readability: Prefer named arguments for functions with multiple parameters, especially boolean flags, to enhance code readability.
• Use Default Parameters Wisely: Default parameters can simplify API usage but use them judiciously to avoid confusion about function behavior.
• Leverage Higher-Order Functions: Embrace higher-order functions for more expressive and concise code, especially when working with collections or implementing patterns that benefit from function composition.